home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Mark Pilgrim / Shutdown FX 2.1 / source / Fade module ƒ / ◊ Reversed fades ƒ / Hilbert fade reversed.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-30  |  4.2 KB  |  155 lines  |  [TEXT/KAHL]
  1. /**********************************************************************\
  2.  
  3. File:        Hilbert wipe fade.c
  4.  
  5. Purpose:    Graphic effect to fade main window to solid pattern.
  6.             See comments below for more description.
  7.  
  8. This program is free software; you can redistribute it and/or modify
  9. it under the terms of the GNU General Public License as published by
  10. the Free Software Foundation; either version 2 of the License, or
  11. (at your option) any later version.
  12.  
  13. This program is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with this program in a file named "GNU General Public License".
  20. If not, write to the Free Software Foundation, 675 Mass Ave,
  21. Cambridge, MA 02139, USA.
  22.  
  23. \**********************************************************************/
  24.  
  25. #include "timing.h"
  26.  
  27. /* This fills the screen by a Hilbert space-filling curve, which is defined by
  28.    two mutually recursive drawing functions:
  29.    
  30.    X = left, Y, draw, right, X, draw, X, right, draw, Y, left
  31.    Y = right, X, draw, left, Y, draw, Y, left, draw, X, right
  32.    
  33.    Start by drawing X at the highest recursion level from the bottomleft of the
  34.    screen. (At recursion level 1, X and Y are null functions.)
  35. */
  36.  
  37. #define    RecursionLevel    4
  38. #define CorrectTime 1
  39. #define theWindowHeight (boundsRect.bottom-boundsRect.top)
  40. #define theWindowWidth (boundsRect.right-boundsRect.left)
  41.  
  42. pascal void HilbertFadeRecurse(Rect boundsRect, Pattern *thePattern,
  43.     short level, short whichpattern, short* x, short* y, short* HilbertDirection,
  44.     short vBlockSize, short hBlockSize);
  45.  
  46. pascal short main(Rect boundsRect, Pattern *thePattern);
  47.  
  48.  
  49. pascal void HilbertFadeRecurse(Rect boundsRect, Pattern *thePattern,
  50.     short level, short whichpattern, short* x, short* y, short* HilbertDirection,
  51.     short vBlockSize, short hBlockSize)
  52. {
  53.     short            i;
  54.     Rect            source;
  55.     unsigned char    theChar;
  56.     
  57.     for (i=0; i<11; i++)
  58.     {
  59.         theChar=0xEE;
  60.         switch (i)
  61.         {
  62.             case 0:
  63.             case 10:
  64.                 theChar=(whichpattern==0) ? 0x02 : 0x01;
  65.                 break;
  66.             case 1:
  67.             case 9:
  68.                 theChar=(whichpattern==0) ? 0x69 : 0x42;
  69.                 break;
  70.             case 2:
  71.             case 5:
  72.             case 8:
  73.                 theChar=0x00;
  74.                 break;
  75.             case 3:
  76.             case 7:
  77.                 theChar=(whichpattern==0) ? 0x01 : 0x02;
  78.                 break;
  79.             case 4:
  80.             case 6:
  81.                 theChar=(whichpattern==0) ? 0x42 : 0x69;
  82.                 break;
  83.         }
  84.         
  85.         switch (theChar)
  86.         {
  87.             case 0x01:     /* turn left */
  88.                 (*HilbertDirection)--;
  89.                 if ((*HilbertDirection)<0) (*HilbertDirection)=3;
  90.                 break;
  91.             case 0x02:     /* turn right */
  92.                 (*HilbertDirection)++;
  93.                 if ((*HilbertDirection)==4) (*HilbertDirection)=0;
  94.                 break;
  95.             case 0x00:    /* draw */
  96.                 StartTiming();
  97.                 SetRect(&source, theWindowWidth-*x-hBlockSize, *y-vBlockSize,
  98.                     theWindowWidth-*x, *y);
  99.                 OffsetRect(&source, boundsRect.left, boundsRect.top);
  100.                 SectRect(&source, &boundsRect, &source);
  101.                 FillRect(&source, *thePattern);
  102.                 switch (*HilbertDirection)
  103.                 {
  104.                     case 0:
  105.                         *x+=hBlockSize;
  106.                         break;
  107.                     case 1:
  108.                         *y-=vBlockSize;
  109.                         break;
  110.                     case 2:
  111.                         *x-=hBlockSize;
  112.                         break;
  113.                     case 3:
  114.                         *y+=vBlockSize;
  115.                         break;
  116.                 }
  117.                 TimeCorrection(CorrectTime);
  118.                 break;
  119.             case 0x42:    /* call X */
  120.                 if (level>1)
  121.                     HilbertFadeRecurse(boundsRect,thePattern,level-1,0,x,y,
  122.                         HilbertDirection, vBlockSize, hBlockSize);
  123.                 break;
  124.             case 0x69:    /* call Y */
  125.                 if (level>1)
  126.                     HilbertFadeRecurse(boundsRect,thePattern,level-1,1,x,y,
  127.                         HilbertDirection, vBlockSize, hBlockSize);
  128.                 break;
  129.         }
  130.     }
  131. }
  132.  
  133. pascal short main(Rect boundsRect, Pattern *thePattern)
  134. {
  135.     short        curx, cury;
  136.     short        answer, i;
  137.     short        HilbertDirection;
  138.     short        vBlockSize;
  139.     short        hBlockSize;
  140.     
  141.     answer=1;
  142.     for (i=0; i<RecursionLevel; i++)
  143.         answer*=2;
  144.     vBlockSize=1+theWindowHeight/answer;    /* used to be 20 */
  145.     hBlockSize=1+theWindowWidth/answer;        /* used to be 32 */
  146.     HilbertDirection=0;
  147.     cury=theWindowHeight;
  148.     curx=0;
  149.     HilbertFadeRecurse(boundsRect,thePattern,RecursionLevel,0,&curx,&cury,
  150.         &HilbertDirection, vBlockSize, hBlockSize);
  151.     FillRect(&boundsRect, *thePattern);        /* in case we missed any bits */
  152.     
  153.     return 0;
  154. }
  155.